//这是关于String的学习测试代码

import javax.sound.midi.Soundbank;
import java.util.Scanner;

public class Test {

    public static void main(String[] args) {
        //验证回文串
        //如果在将所有大写字符转换为小写字符、并移除所有非字母数字字符之后，短语正着读和反着读都一样。则可以认为该短语是一个回文串。
        //字母和数字都属于字母数字字符。
        //给你一个字符串s，如果它是回文串，返回true；否则，返回false。
        class Solution {
            private boolean isLeagal (char ch){
                if ((ch >= '0' && ch <= '9') || (ch >= 'a' && ch <= 'z')){
                    return true;
                }
                return false;
            }
            public boolean isPalindrome(String s){
                s = s.toLowerCase();
                int left = 0;
                int right = s.length() - 1;

                while (left < right){
                    while (left < right && !isLeagal(s.charAt(left))){
                        left++;
                    }
                    while (left < right && !isLeagal(s.charAt(right))){
                        right--;
                    }
                    if (s.charAt(left) == s.charAt(right)){
                        left++;
                        right--;
                    }else {
                        return false;
                    }
                }
                return true;
            }
        }
        Solution solution = new Solution();
        System.out.println(solution.isPalindrome("race a car"));
    }
    public static void main14(String[] args) {
        //计算字符串最后一个单词的长度，单词以空格隔开，字符串长度小于5000。（注：字符串末尾不以空格为结尾）
        //输入描述：
        //输入一行，代表要计算的字符串，非空，长度小于5000。
        //输出描述：
        //输出一个整数，表示输入字符串最后一个单词的长度。
        //示例1
        //输入：hello nowcoder
        //输出：8
        //说明：最后一个单词为nowcoder，长度为8
        Scanner sc = new Scanner(System.in);

        while (sc.hasNextLine()) {
            String s = sc.nextLine();
            int k = s.lastIndexOf(' ');
            String ret = s.substring(k + 1);
            System.out.println(ret.length());
            //substring返回一个字符串
        }
    }
    public static void main13(String[] args) {
        //给定一个字符串s，找到它的第一个不重复的字符，并返回它的索引.如果不存在，则返回-1;
        //示例 1：
        //输入: s = "leetcode"
        //输出: 0
        //示例 2:
        //输入: s = "loveleetcode"
        //输出: 2
        //示例 3:
        //输入: s = "aabb"
        //输出: -1
        class Solution {
            public int firstUniqChar(String s){
                int[] count = new int[26];
                for (int i = 0; i < s.length(); i++){
                    char ch = s.charAt(i);
                    count[s.charAt(i) - 'a']++;
                }
                for (int i = 0; i < s.length(); i++){
                    char ch = s.charAt(i);
                    if (1 == count[ch - 'a']){
                        return i;
                    }
                }
                return -1;
            }
        }
        Solution solution = new Solution();
        System.out.println(solution.firstUniqChar("loveleetcode"));
    }

    public static void main12(String[] args) {
        String s1 = "abc" + "def";//1
        String s2 = new String(s1);//2
        if (s1.equals(s2))//3
            System.out.println(".equals succeeded");//4
        if (s1 == s2)//5
            System.out.println("==succeeded");//6

    }

    public static void main11(String[] args) {
        long start = System.currentTimeMillis();
        String s = "";
        for (int i = 0; i < 10000; ++i) {
            s += i;
        }
        long end = System.currentTimeMillis();
        System.out.println(end - start);


        start = System.currentTimeMillis();
        StringBuffer sbf = new StringBuffer("");
        for (int i = 0; i < 10000; ++i) {
            sbf.append(i);
        }
        end = System.currentTimeMillis();
        System.out.println(end - start);

        start = System.currentTimeMillis();
        StringBuilder sbd = new StringBuilder();
        for (int i = 0; i < 10000; ++i) {
            sbd.append(i);
        }
        end = System.currentTimeMillis();
        System.out.println(end - start);
    }

    public static void main10(String[] args) {
        //字符串截取
        String str = "helloworld";
        System.out.println(str.substring(1));
        System.out.println(str.substring(1, 4));
        //索引从零开始，左闭右开

        String s = "      hello  world     ";
        System.out.println(s);
        System.out.println(s.trim());
//        String trim();去掉字符串中的左右空格，但中间的空格会保留
    }

    public static void main9(String[] args) {
        //拆分字符串
        String str = "abcde=haw=wa=w=a";
        String[] ret = str.split("=|&");
        for (String s : ret) {
            System.out.println(s);
        }
        System.out.println(" ==================== ");
        String[] ret2 = str.split("=", 3);
        for (String s : ret2) {
            System.out.println(s);
        }
        System.out.println("========================");

        //字符"|"","*""+"都需要加上转义字符\\
        //如果是"\"需要写成"\\\\"
        //一个字符中有多个分隔符，则 中间用 | 连接

        //多次拆分
        String string = "name=zzr&1300310481=qqcom";
        String[] strings = string.split("=");
        for (int i = 0; i < strings.length; i++) {
            String[] sting1 = strings[i].split("&");
            for (int j = 0; j < sting1.length; j++) {
                String[] string2 = sting1[j].split("@");
                for (int k = 0; k < string2.length; k++) {
                    System.out.println(string2[k]);
                }
            }
        }
    }

    public static void main8(String[] args) {
        //字符串替换
        String str = "abcabcdabcde";
        String ret = str.replace("a", "ooo");
        //这个替换也是 并不是在原来的字符串的基础上进行替换，他是产生了新的对象 进行返回
        System.out.println(ret);
        System.out.println("==============");
        String ret1 = str.replace('a', 'z');
        System.out.println(ret1);

        String ret2 = str.replaceAll("ab", "kk");
        System.out.println(ret2);

        String ret3 = str.replaceFirst("ab", "kk");
        System.out.println(ret3);
    }

    public static void main7(String[] args) {

        class Student {
            String name;
            int age;

            public Student(String name, int age) {
                this.name = name;
                this.age = age;
            }
        }
        //转换
        //注意：在Java中，String是不可变的
        //hello --> HELLO 下面这些转换并不是在原来的字符串基础上进行转换的，他们都是生成了一个新的对象 并返回 从而实现的
        String s1 = String.valueOf(1234);
        String s2 = String.valueOf(12.34);
        String s3 = String.valueOf(true);
        String s4 = String.valueOf(new Student("zzr", 18));

        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s3);
        System.out.println(s4);

        System.out.println("======================");

        //字符串转数字
        int data1 = Integer.parseInt("1234");
        double data2 = Double.parseDouble("12.34");
        System.out.println(data1);
        System.out.println(data2);
        System.out.println("========================");

        //大小写转换
        String str = "heLLo World";

        String ret = str.toUpperCase(); //toUpperCase 返回一个String类型
        System.out.println(ret);
        String ret1 = str.toLowerCase();
        System.out.println(ret1);

        System.out.println("=========================");

        //字符串转数组
        String str4 = "hello zzr";
        char v[] = str4.toCharArray();
        for (int i = 0; i < str4.length(); i++) {
            System.out.println(v[i]);
        }
        System.out.println("======================");

        //数组转字符串
        String arr = new String(v);
        System.out.println(arr);
    }

    public static void main6(String[] args) {
        //字符串查找
        //方法
        //1.char charAt(int index)
        String s = new String("abc");
        System.out.println(s.charAt(1));//b

        //2.int indexOf(int ch)
        //从前往后找第一次ch出现的位置
        System.out.println(s.indexOf('b'));//1

        //3.int indexOf (int ch, int fromIndex)
        //从fromIndex位置开始向后找
        String s2 = new String("abbbbbbbbccccda");
        System.out.println(s2.indexOf('a', 1));//14

        //4.int indexOf(String str)
        //返回str第一次出现的位置的下标
        System.out.println(s2.indexOf("bbb"));

        //5.int indexOf(String str, int fromIndex)

        //6.int lastIndexOf(int ch)
        //从后往前找

    }

    public static void main5(String[] args) {
        //int compareToIgnoreCase(String s) 与compareTo相似，只是忽略大小写
        String s1 = new String("abc");
        String s2 = new String("aBc");
        System.out.println(s1.compareTo(s2));// 32
        System.out.println(s1.compareToIgnoreCase(s2)); //0
    }

    public static void main4(String[] args) {
        //int compareTo(String s)方法
        //与equals不同， compareTo返回的是int类型
        //1.先按照字典次序大小比较，如果出现不等的字符，直接返回两个字符的大小差值
        //2.如果前K个字符相等，则返回两个字符串长度差值
        String s1 = new String("abdde");
        String s2 = new String("abc");
        System.out.println(s1.compareTo(s2));//1
        String s3 = new String("abcde");
        System.out.println(s3.compareTo(s2));//2
        System.out.println(s2.compareTo(s3));//-2
    }

    @Override
    public boolean equals(Object obj) {
        //1. 先检测this 和 obj是否为同一个对象比较
        if (this == obj) {
            return true;
        }

        //2.检测obj是否是String类型的对象
        if (obj instanceof String) {
            //obj向下转型为String
            String anotherString = (String) obj;
            int n = ((String) obj).length();

            if (n == anotherString.length()) {
                char[] v1 = anotherString.toCharArray();
                char[] v2 = ((String) obj).toCharArray();
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i]) {
                        return false;
                    }
                    i++;
                }
                return true;
            }
        }
        return false;
    }

    public static void main3(String[] args) {
        //Java中提供的字符串比较
        // 1. == 比较是否引用同一个对象
        //内置类型， == 比较的是变量中的值， 引用类型的 == 比较的是引用中的地址

        // == 比较是否引用同一个对象
        //任何情况下 只要 == 两边是引用类型
        //一定要注意看，此时比较的是书名？
        //如何比较两个引用所指向的内容是否相同？
        //重写equals 和 hascode方法

        //2.boolean equals(Object anObject)方法：按照字典序比较

        String str1 = new String("aaa");
        String str2 = new String("aaa");
        System.out.println(str1.equals(str2));
    }

    public static void main2(String[] args) {
        String str1 = new String("hello");
        String str2 = new String("hello");

        System.out.println(str1 == str2);//false

        System.out.println(str1.equals(str2));//true String的equals方法重写了父类的Object的equals方法

        String str3 = "abcde";
        String str4 = "abcde";
        System.out.println(str3 == str4);//true 字符串常量池
    }

    public static void main1(String[] args) {
        //字符串的构造

        //使用常量串构造
        String s1 = "hello world";
        System.out.println(s1);

        //newString 对象
        String s2 = new String("zzr");
        System.out.println(s2);

        //使用字符数组进行构造
        char[] array = {'a', 'b', 'c', 'd'};
        String s3 = new String(array);
        System.out.println(s3);

        //String是引用类型，内部并不存储字符串本身

        System.out.println("hello".length());
        //只要被 “” 引起来的 全是String类型

        String str = "hello";
        //与c语言做区别的是 Java中字符串并没有以\0结尾的说法！
        String str1 = "";
        System.out.println(str1.isEmpty());

        String str2 = null;//str2这个引用，不指向任何对象
        System.out.println(str2.isEmpty());//err .NullPointerException
        //str2不指向任何对象，不能对null类型的变量操作，所以会报错
    }
}
